# -*- coding: utf-8 -*-
import sys
from  PyQt5 import QtCore
from PyQt5.QtWidgets import QApplication, QMainWindow, QTableWidgetItem
from nongmij import Ui_nomiji
from n1 import Ui_Dialog1
from n2 import Ui_Dialog2
from n3 import Ui_Dialog3
from n4 import Ui_Dialog4
from n5 import Ui_Dialog5
from n6 import Ui_Dialog6
from n7 import Ui_Dialog7

#浓密机主界面
class Nomiji(QMainWindow, Ui_nomiji):
    def __init__(self, parent=None):
        super(Nomiji, self).__init__(parent)
        self.setupUi(self)

        #底流浓度修改按钮
        self.p1.clicked.connect(self.open_n1)
        #实例化底流浓度子界面
        self.t1 = N_1()

        #絮凝剂比例修改按钮
        self.p2.clicked.connect(self.open_n2)
        #实例化絮凝剂比列界面
        self.t2 = N_2()

        #泥层压强修改按钮
        self.p3.clicked.connect(self.open_n3)
        #实例化泥层压强界面
        self.t3 = N_3()

        #耙架转速修改按钮
        self.p4.clicked.connect(self.open_n4)
        #实例化耙架转速界面
        self.t4 = N_4()

        #稀释水流量修改按钮
        self.p5.clicked.connect(self.open_n5)
        #实例化稀释水流量界面
        self.t5 = N_5()

        #底流流量修改按钮
        self.p6.clicked.connect(self.open_n6)
        #实例化底流流量界面
        self.t6 = N_6()

        #絮凝剂流量修改按钮
        self.p7.clicked.connect(self.open_n7)
        #絮凝剂流量转速界面
        self.t7 = N_7()

    def open_n1(self):
        #打开底流浓度修改界面
        self.t1.show()
        #信号传递
        self.t1.Shizhi1.connect(self.getData1)
        self.t1.S_Moshi1.connect(self.get_Sheding_moshi1)
        self.t1.K_Moshi1.connect(self.get_Kongzhi_moshi1)
        self.t1.DILIUNONGDU.connect(self.SetDLNU)

    def open_n2(self):
        #打开絮凝剂比列修改界面
        self.t2.show()
        #上级信号控制
        self.t2.shangjikongzhi(self.DLND)
        #信号传递
        self.t2.Shizhi_2.connect(self.getData_2)
        self.t2.S_Moshi_2.connect(self.get_Sheding_moshi_2)
        self.t2.K_Moshi_2.connect(self.get_Kongzhi_moshi_2)

    def open_n3(self):
        #打开泥层压强修改界面
        self.t3.show()
        #上级信号控制
        self.t3.shangjikongzhi(self.DLND)
        #信号传递
        self.t3.Shizhi_3.connect(self.getData_3)
        self.t3.S_Moshi_3.connect(self.get_Sheding_moshi_3)
        self.t3.K_Moshi_3.connect(self.get_Kongzhi_moshi_3)

    def open_n4(self):
        #打开耙架转速修改界面
        self.t4.show()
        #信号传递
        self.t4.Shizhi_4.connect(self.getData_4)
        self.t4.S_Moshi_4.connect(self.get_Sheding_moshi_4)
        self.t4.K_Moshi_4.connect(self.get_Kongzhi_moshi_4)

    def open_n5(self):
        #打开稀释水流量修改界面
        self.t5.show()
        #上级信号控制
        self.t5.shangjikongzhi(self.DLND)
        #信号传递
        self.t5.Shizhi_5.connect(self.getData_5)
        self.t5.S_Moshi_5.connect(self.get_Sheding_moshi_5)
        self.t5.K_Moshi_5.connect(self.get_Kongzhi_moshi_5)

    def open_n6(self):
        #打开底流流量修改界面
        self.t6.show()
        #信号传递
        self.t6.Shizhi_6.connect(self.getData_6)
        self.t6.S_Moshi_6.connect(self.get_Sheding_moshi_6)
        self.t6.K_Moshi_6.connect(self.get_Kongzhi_moshi_6)

    def open_n7(self):
        #打开絮凝剂流量修改界面
        self.t7.show()
        #信号传递
        self.t7.Shizhi_7.connect(self.getData_7)
        self.t7.S_Moshi_7.connect(self.get_Sheding_moshi_7)
        self.t7.K_Moshi_7.connect(self.get_Kongzhi_moshi_7)

#底流浓度界面
class N_1(QMainWindow,Ui_Dialog1):
    #底流浓度设置值定义
    Shizhi1=QtCore.pyqtSignal(str)
    #底流浓度设定模式定义
    S_Moshi1=QtCore.pyqtSignal(str)
    #底流浓度控制模式定义
    K_Moshi1=QtCore.pyqtSignal(str)
    #底流浓度智能模式信号定义
    DILIUNONGDU = QtCore.pyqtSignal(bool)
    def __init__(self):
        super(N_1, self).__init__()
        self.setupUi(self)
        self.retranslateUi(self)
        #确定按钮
        self.pushButton.clicked.connect(self.moshi)
        #关闭按钮
        self.pushButton_2.clicked.connect(self.close)
        #滑动条实时显示数值
        self.horizontalSlider.valueChanged.connect(self.SliderValue)
        #手动设定与智能控制互斥
        self.radioButton_2.clicked.connect(self.huchi1)
        self.radioButton_3.clicked.connect(self.huchi2)

    #手动设定确定
    def Shezhi(self):
        data=self.lineEdit.text()
        f_data=float(data)
        #判断设置值是否符合规定
        if f_data>=52.0 and f_data<=74.0:
            if self.horizontalSlider.value() != float(self.shoudongzhi) and f_data == float(self.shoudongzhi):
                f_data = self.horizontalSlider.value()/100
            sd = str(f_data)
            #传导信号
            self.Shizhi1.emit(sd)
            #用于保存正确的手动设定值
            self.shoudongzhi=sd
            #更改模式
            self.S_Moshi1.emit("手动设定")
        #不合规定的情况（待修改）
        else:
            pass
        #保存手动设定值
        self.lineEdit.setText(self.shoudongzhi)
        self.horizontalSlider.setValue(float(self.shoudongzhi)*100)
    #模式设定
    def moshi(self):
        #设置为智能设定
        if self.radioButton.isChecked() == True:
            # 更改模式（待修改）
            self.radioButton.setChecked(True)
            self.S_Moshi1.emit("智能设定")
        #设置为手动设定
        if self.radioButton_2.isChecked() == True:
            self.radioButton_2.setChecked(True)
            #手动设定值修改
            self.Shezhi()
        #设置为智能控制
        if self.radioButton_3.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_3.setChecked(True)
            self.K_Moshi1.emit("智能控制")
            self.DILIUNONGDU.emit(True)
        #关闭智能模式
        if self.radioButton_4.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_4.setChecked(True)
            self.K_Moshi1.emit("关闭")
            self.DILIUNONGDU.emit(False)
        #关闭子窗口
        self.close()

#絮凝剂比例界面
class N_2(QMainWindow,Ui_Dialog2):
    #絮凝剂比例设定值定义
    Shizhi_2=QtCore.pyqtSignal(str)
    #絮凝剂比例设定模式定义
    S_Moshi_2=QtCore.pyqtSignal(str)
    #絮凝剂比例控制模式定义
    K_Moshi_2=QtCore.pyqtSignal(str)
    def __init__(self):
        super(N_2, self).__init__()
        self.setupUi(self)
        self.retranslateUi(self)

        #关闭按钮
        self.pushButton_2.clicked.connect(self.close)
        #确定按钮
        self.pushButton.clicked.connect(self.moshi)
        #滑动条实时显示数值
        self.horizontalSlider.valueChanged.connect(self.SliderValue)
        #手动设定与智能控制互斥
        self.radioButton_2.clicked.connect(self.huchi1)
        self.radioButton_3.clicked.connect(self.huchi2)

    #上级控制器控制
    def shangjikongzhi(self,parameter):
        if parameter==False:
            self.radioButton_3.setEnabled(False)
        else:
            self.radioButton_3.setEnabled(True)
    #模式设定
    def moshi(self):
        #设置为智能设定
        if self.radioButton.isChecked() == True:
            # 更改模式（待修改）
            self.radioButton.setChecked(True)
            self.S_Moshi_2.emit("智能设定")
        #设置为手动设定
        if self.radioButton_2.isChecked() == True:
            self.radioButton_2.setChecked(True)
            #手动设定值修改
            self.Shezhi()
        #设置为智能控制
        if self.radioButton_3.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_3.setChecked(True)
            self.K_Moshi_2.emit("智能控制")
        #关闭智能模式
        if self.radioButton_4.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_4.setChecked(True)
            self.K_Moshi_2.emit("关闭")
        #关闭子窗口
        self.close()

    #手动设定确定
    def Shezhi(self):
        data=self.lineEdit.text()
        f_data=float(data)
        #判断设置值是否符合规定
        if f_data>=3.0 and f_data<=6.0:
            if self.horizontalSlider.value() != float(self.shoudongzhi) and f_data == float(self.shoudongzhi):
                f_data = self.horizontalSlider.value()/100
            sd = str(f_data)
            #传导信号
            self.Shizhi_2.emit(sd)
            #用于保存正确的手动设定值
            self.shoudongzhi=sd
            #更改模式
            self.S_Moshi_2.emit("手动设定")
        #不合规定的情况（待修改）
        else:
            pass
        #保存手动设定值
        self.lineEdit.setText(self.shoudongzhi)
        self.horizontalSlider.setValue(float(self.shoudongzhi)*100)

#泥层压强
class N_3(QMainWindow,Ui_Dialog3):
    #泥层压强设定值定义
    Shizhi_3=QtCore.pyqtSignal(str)
    #泥层压强设定模式定义
    S_Moshi_3=QtCore.pyqtSignal(str)
    #泥层压强控制模式定义
    K_Moshi_3=QtCore.pyqtSignal(str)
    def __init__(self):
        super(N_3, self).__init__()
        self.setupUi(self)
        self.retranslateUi(self)
        #关闭按钮
        self.pushButton_2.clicked.connect(self.close)
        #确定按钮
        self.pushButton.clicked.connect(self.moshi)
        #滑动条实时显示数值
        self.horizontalSlider.valueChanged.connect(self.SliderValue)
        #手动设定与智能控制互斥
        self.radioButton_2.clicked.connect(self.huchi1)
        self.radioButton_3.clicked.connect(self.huchi2)

    #上级控制器控制
    def shangjikongzhi(self,parameter):
        if parameter==False:
            self.radioButton_3.setEnabled(False)
        else:
            self.radioButton_3.setEnabled(True)
    #模式设定
    def moshi(self):
        #设置为智能设定
        if self.radioButton.isChecked() == True:
            # 更改模式（待修改）
            self.radioButton.setChecked(True)
            self.S_Moshi_3.emit("智能设定")
        #设置为手动设定
        if self.radioButton_2.isChecked() == True:
            self.radioButton_2.setChecked(True)
            #手动设定值修改
            self.Shezhi()
        #设置为智能控制
        if self.radioButton_3.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_3.setChecked(True)
            self.K_Moshi_3.emit("智能控制")
        #关闭智能模式
        if self.radioButton_4.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_4.setChecked(True)
            self.K_Moshi_3.emit("关闭")
        #关闭子窗口
        self.close()

    #手动设定确定
    def Shezhi(self):
        data=self.lineEdit.text()
        f_data=float(data)
        #判断设置值是否符合规定
        if f_data>=100.0 and f_data<=600.0:
            if self.horizontalSlider.value() != float(self.shoudongzhi) and f_data == float(self.shoudongzhi):
                f_data = self.horizontalSlider.value()/100
            sd = str(f_data)
            #传导信号
            self.Shizhi_3.emit(sd)
            #用于保存正确的手动设定值
            self.shoudongzhi=sd
            #更改模式
            self.S_Moshi_3.emit("手动设定")
        #不合规定的情况（待修改）
        else:
            pass
        #保存手动设定值
        self.lineEdit.setText(self.shoudongzhi)
        self.horizontalSlider.setValue(float(self.shoudongzhi)*100)

#耙架转速
class N_4(QMainWindow,Ui_Dialog4):
    #耙架转速设定值定义
    Shizhi_4=QtCore.pyqtSignal(str)
    #耙架转速设定模式定义
    S_Moshi_4=QtCore.pyqtSignal(str)
    #耙架转速控制模式定义
    K_Moshi_4=QtCore.pyqtSignal(str)
    def __init__(self):
        super(N_4, self).__init__()
        self.setupUi(self)
        self.retranslateUi(self)
        #关闭按钮
        self.pushButton_2.clicked.connect(self.close)
        #确定按钮
        self.pushButton.clicked.connect(self.moshi)
        #滑动条实时显示数值
        self.horizontalSlider.valueChanged.connect(self.SliderValue)

    #模式设定
    def moshi(self):
        #设置为智能设定
        if self.radioButton.isChecked() == True:
            # 更改模式（待修改）
            self.radioButton.setChecked(True)
            self.S_Moshi_4.emit("智能设定")
        #设置为手动设定
        if self.radioButton_2.isChecked() == True:
            self.radioButton_2.setChecked(True)
            #手动设定值修改
            self.Shezhi()

        #关闭模式
        if self.radioButton_4.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_4.setChecked(True)
            self.K_Moshi_4.emit("关闭")
        else:
            #更改模式（待修改）
            self.K_Moshi_4.emit("智能控制")
        #关闭子窗口
        self.close()

    #手动设定确定
    def Shezhi(self):
        data=self.lineEdit.text()
        f_data=float(data)
        #判断设置值是否符合规定
        if f_data>=60.0 and f_data<=80.0:
            if self.horizontalSlider.value() != float(self.shoudongzhi) and f_data == float(self.shoudongzhi):
                f_data = self.horizontalSlider.value()/100
            sd = str(f_data)
            #传导信号
            self.Shizhi_4.emit(sd)
            #用于保存正确的手动设定值
            self.shoudongzhi=sd
            #更改模式
            self.S_Moshi_4.emit("手动设定")
        #不合规定的情况（待修改）
        else:
            pass
        #保存手动设定值
        self.lineEdit.setText(self.shoudongzhi)
        self.horizontalSlider.setValue(float(self.shoudongzhi)*100)

#稀释水流量
class N_5(QMainWindow,Ui_Dialog5):
    #稀释水流量设定值定义
    Shizhi_5=QtCore.pyqtSignal(str)
    #稀释水流量设定模式定义
    S_Moshi_5=QtCore.pyqtSignal(str)
    #稀释水流量控制模式定义
    K_Moshi_5=QtCore.pyqtSignal(str)
    def __init__(self):
        super(N_5, self).__init__()
        self.setupUi(self)
        self.retranslateUi(self)
        #关闭按钮
        self.pushButton_2.clicked.connect(self.close)
        #确定按钮
        self.pushButton.clicked.connect(self.moshi)
        #滑动条实时显示数值
        self.horizontalSlider.valueChanged.connect(self.SliderValue)
        #手动设定与智能控制互斥
        self.radioButton_2.clicked.connect(self.huchi1)
        self.radioButton_3.clicked.connect(self.huchi2)

    #上级控制器控制
    def shangjikongzhi(self,parameter):
        if parameter==False:
            self.radioButton_3.setEnabled(False)
        else:
            self.radioButton_3.setEnabled(True)
    #模式设定
    def moshi(self):
        #设置为智能设定
        if self.radioButton.isChecked() == True:
            # 更改模式（待修改）
            self.radioButton.setChecked(True)
            self.S_Moshi_5.emit("智能设定")
        #设置为手动设定
        if self.radioButton_2.isChecked() == True:
            self.radioButton_2.setChecked(True)
            #手动设定值修改
            self.Shezhi()
        #设置为智能控制
        if self.radioButton_3.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_3.setChecked(True)
            self.K_Moshi_5.emit("智能控制")
        #关闭智能模式
        if self.radioButton_4.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_4.setChecked(True)
            self.K_Moshi_5.emit("关闭")
        #关闭子窗口
        self.close()

    #手动设定确定
    def Shezhi(self):
        data=self.lineEdit.text()
        f_data=float(data)
        #判断设置值是否符合规定
        if f_data>=0.0 and f_data<=200.0:
            if self.horizontalSlider.value() != float(self.shoudongzhi) and f_data == float(self.shoudongzhi):
                f_data = self.horizontalSlider.value()/100
            sd = str(f_data)
            #传导信号
            self.Shizhi_5.emit(sd)
            #用于保存正确的手动设定值
            self.shoudongzhi=sd
            #更改模式
            self.S_Moshi_5.emit("手动设定")
        #不合规定的情况（待修改）
        else:
            pass
        #保存手动设定值
        self.lineEdit.setText(self.shoudongzhi)
        self.horizontalSlider.setValue(float(self.shoudongzhi)*100)

#底流流量
class N_6(QMainWindow,Ui_Dialog6):
    #底流流量设定值定义
    Shizhi_6=QtCore.pyqtSignal(str)
    #底流流量设定模式定义
    S_Moshi_6=QtCore.pyqtSignal(str)
    #底流流量控制模式定义
    K_Moshi_6=QtCore.pyqtSignal(str)
    def __init__(self):
        super(N_6, self).__init__()
        self.setupUi(self)
        self.retranslateUi(self)
        #关闭按钮
        self.pushButton_2.clicked.connect(self.close)
        #确定按钮
        self.pushButton.clicked.connect(self.moshi)
        #滑动条实时显示数值
        self.horizontalSlider.valueChanged.connect(self.SliderValue)


    #模式设定
    def moshi(self):
        #设置为智能设定
        if self.radioButton.isChecked() == True:
            # 更改模式（待修改）
            self.radioButton.setChecked(True)
            self.S_Moshi_6.emit("智能设定")
        #设置为手动设定
        if self.radioButton_2.isChecked() == True:
            self.radioButton_2.setChecked(True)
            #手动设定值修改
            self.Shezhi()

        #关闭智能模式
        if self.radioButton_4.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_4.setChecked(True)
            self.K_Moshi_6.emit("关闭")
        else:
            #更改模式（待修改）
            self.K_Moshi_6.emit("智能控制")
        #关闭子窗口
        self.close()

    #手动设定确定
    def Shezhi(self):
        data=self.lineEdit.text()
        f_data=float(data)
        #判断设置值是否符合规定
        if f_data>=0.0 and f_data<=600.0:
            if self.horizontalSlider.value() != float(self.shoudongzhi) and f_data == float(self.shoudongzhi):
                f_data = self.horizontalSlider.value()/100
            sd = str(f_data)
            #传导信号
            self.Shizhi_6.emit(sd)
            #用于保存正确的手动设定值
            self.shoudongzhi=sd
            #更改模式
            self.S_Moshi_6.emit("手动设定")
        #不合规定的情况（待修改）
        else:
            pass
        #保存手动设定值
        self.lineEdit.setText(self.shoudongzhi)
        self.horizontalSlider.setValue(float(self.shoudongzhi)*100)

#絮凝剂流量
class N_7(QMainWindow,Ui_Dialog7):
    #絮凝剂流量设定值定义
    Shizhi_7=QtCore.pyqtSignal(str)
    #絮凝剂流量设定模式定义
    S_Moshi_7=QtCore.pyqtSignal(str)
    #絮凝剂流量控制模式定义
    K_Moshi_7=QtCore.pyqtSignal(str)
    def __init__(self):
        super(N_7, self).__init__()
        self.setupUi(self)
        self.retranslateUi(self)
        #关闭按钮
        self.pushButton_2.clicked.connect(self.close)
        #确定按钮
        self.pushButton.clicked.connect(self.moshi)
        #滑动条实时显示数值
        self.horizontalSlider.valueChanged.connect(self.SliderValue)


    #模式设定
    def moshi(self):
        #设置为智能设定
        if self.radioButton.isChecked() == True:
            # 更改模式（待修改）
            self.radioButton.setChecked(True)
            self.S_Moshi_7.emit("智能设定")
        #设置为手动设定
        if self.radioButton_2.isChecked() == True:
            self.radioButton_2.setChecked(True)
            #手动设定值修改
            self.Shezhi()

        #关闭智能模式
        if self.radioButton_4.isChecked()==True:
            # 更改模式（待修改）
            self.radioButton_4.setChecked(True)
            self.K_Moshi_7.emit("关闭")
        else:
            #更改模式（待修改）
            self.K_Moshi_7.emit("智能控制")
        #关闭子窗口
        self.close()

    #手动设定确定
    def Shezhi(self):
        data=self.lineEdit.text()
        f_data=float(data)
        #判断设置值是否符合规定
        if f_data>=0.0 and f_data<=20.0:
            if self.horizontalSlider.value() != float(self.shoudongzhi) and f_data == float(self.shoudongzhi):
                f_data = self.horizontalSlider.value()/100
            sd = str(f_data)
            #传导信号
            self.Shizhi_7.emit(sd)
            #用于保存正确的手动设定值
            self.shoudongzhi=sd
            #更改模式
            self.S_Moshi_7.emit("手动设定")
        #不合规定的情况（待修改）
        else:
            pass
        #保存手动设定值
        self.lineEdit.setText(self.shoudongzhi)
        self.horizontalSlider.setValue(float(self.shoudongzhi)*100)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    MainWindow_Nomiji = Nomiji()
    ChildWindow_1 = N_1()
    ChildWindow_2 = N_2()
    ChildWindow_3 = N_3()
    ChildWindow_4 = N_4()
    ChildWindow_5 = N_5()
    ChildWindow_6 = N_6()
    ChildWindow_7 = N_7()
    MainWindow_Nomiji.show()
    sys.exit(app.exec_())
